gesture = gtk_gesture_swipe_new (drawing_area);
g_signal_connect (gesture, "swipe",
G_CALLBACK (swipe_gesture_swept), drawing_area);
- gtk_widget_add_controller (drawing_area, GTK_EVENT_CONTROLLER (gesture));
+ gtk_gesture_attach (gesture, GTK_PHASE_BUBBLE);
g_object_unref (gesture);
/* Long press */
G_CALLBACK (long_press_gesture_pressed), drawing_area);
g_signal_connect (gesture, "end",
G_CALLBACK (long_press_gesture_end), drawing_area);
- gtk_widget_add_controller (drawing_area, GTK_EVENT_CONTROLLER (gesture));
+ gtk_gesture_attach (gesture, GTK_PHASE_BUBBLE);
g_object_unref (gesture);
/* Rotate */
rotate = gesture = gtk_gesture_rotate_new (drawing_area);
g_signal_connect (gesture, "angle-changed",
G_CALLBACK (rotation_angle_changed), drawing_area);
- gtk_widget_add_controller (drawing_area, GTK_EVENT_CONTROLLER (gesture));
+ gtk_gesture_attach (gesture, GTK_PHASE_BUBBLE);
g_object_unref (gesture);
/* Zoom */
zoom = gesture = gtk_gesture_zoom_new (drawing_area);
g_signal_connect (gesture, "scale-changed",
G_CALLBACK (zoom_scale_changed), drawing_area);
- gtk_widget_add_controller (drawing_area, GTK_EVENT_CONTROLLER (gesture));
+ gtk_gesture_attach (gesture, GTK_PHASE_BUBBLE);
g_object_unref (gesture);
}
gtk_widget_class_bind_template_callback_full
gtk_widget_class_set_connect_func
-<SUBSECTION Gestures>
-gtk_widget_add_controller
-gtk_widget_remove_controller
-gtk_widget_list_controllers
-
<SUBSECTION Standard>
GTK_WIDGET
GTK_IS_WIDGET
<TITLE>GtkEventController</TITLE>
GtkEventController
gtk_event_controller_handle_event
-GtkPropagationPhase
-gtk_event_controller_get_propagation_phase
-gtk_event_controller_set_propagation_phase
gtk_event_controller_get_event_mask
gtk_event_controller_set_event_mask
gtk_event_controller_get_widget
gtk_gesture_cancel_sequence
gtk_gesture_get_sequences
gtk_gesture_handles_sequence
+GtkPropagationPhase
+gtk_gesture_attach
+gtk_gesture_detach
<SUBSECTION>
gtk_gesture_get_last_updated_sequence
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (priv->gesture), GDK_BUTTON_PRIMARY);
g_signal_connect (priv->gesture, "begin", G_CALLBACK (gesture_begin_cb), button);
g_signal_connect (priv->gesture, "end", G_CALLBACK (gesture_end_cb), button);
- gtk_widget_add_controller (GTK_WIDGET (button), GTK_EVENT_CONTROLLER (priv->gesture));
+ gtk_gesture_attach (priv->gesture, GTK_PHASE_BUBBLE);
}
static void
if (priv->gesture)
{
- gtk_widget_remove_controller (widget, GTK_EVENT_CONTROLLER (priv->gesture));
+ gtk_gesture_detach (priv->gesture);
g_object_unref (priv->gesture);
priv->gesture = NULL;
}
plane->priv->long_press_gesture = gtk_gesture_long_press_new (GTK_WIDGET (plane));
g_signal_connect (plane->priv->long_press_gesture, "pressed",
G_CALLBACK (hold_action), plane);
- gtk_widget_add_controller (GTK_WIDGET (plane), GTK_EVENT_CONTROLLER (plane->priv->long_press_gesture));
+ gtk_gesture_attach (plane->priv->long_press_gesture, GTK_PHASE_BUBBLE);
}
static void
g_clear_object (&plane->priv->s_adj);
g_clear_object (&plane->priv->v_adj);
- gtk_widget_remove_controller (GTK_WIDGET (object), GTK_EVENT_CONTROLLER (plane->priv->long_press_gesture));
+ gtk_gesture_detach (plane->priv->long_press_gesture);
g_clear_object (&plane->priv->long_press_gesture);
G_OBJECT_CLASS (gtk_color_plane_parent_class)->finalize (object);
scale->priv->long_press_gesture = gtk_gesture_long_press_new (GTK_WIDGET (scale));
g_signal_connect (scale->priv->long_press_gesture, "pressed",
G_CALLBACK (hold_action), scale);
- gtk_widget_add_controller (GTK_WIDGET (scale),
- GTK_EVENT_CONTROLLER (scale->priv->long_press_gesture));
+ gtk_gesture_attach (scale->priv->long_press_gesture, GTK_PHASE_BUBBLE);
}
static void
if (scale->priv->surface)
cairo_surface_destroy (scale->priv->surface);
- gtk_widget_remove_controller (GTK_WIDGET (object),
- GTK_EVENT_CONTROLLER (scale->priv->long_press_gesture));
+ gtk_gesture_detach (scale->priv->long_press_gesture);
g_clear_object (&scale->priv->long_press_gesture);
G_OBJECT_CLASS (gtk_color_scale_parent_class)->finalize (object);
swatch->priv->long_press_gesture = gtk_gesture_long_press_new (GTK_WIDGET (swatch));
g_signal_connect (swatch->priv->long_press_gesture, "pressed",
G_CALLBACK (hold_action), swatch);
- gtk_widget_add_controller (GTK_WIDGET (swatch),
- GTK_EVENT_CONTROLLER (swatch->priv->long_press_gesture));
+ gtk_gesture_attach (swatch->priv->long_press_gesture, GTK_PHASE_BUBBLE);
swatch->priv->multipress_gesture = gtk_gesture_multi_press_new (GTK_WIDGET (swatch));
g_signal_connect (swatch->priv->multipress_gesture, "pressed",
G_CALLBACK (tap_action), swatch);
- gtk_widget_add_controller (GTK_WIDGET (swatch),
- GTK_EVENT_CONTROLLER (swatch->priv->multipress_gesture));
+ gtk_gesture_attach (swatch->priv->multipress_gesture, GTK_PHASE_BUBBLE);
}
#define INTENSITY(r, g, b) ((r) * 0.30 + (g) * 0.59 + (b) * 0.11)
g_free (swatch->priv->icon);
- gtk_widget_remove_controller (GTK_WIDGET (object),
- GTK_EVENT_CONTROLLER (swatch->priv->long_press_gesture));
+ gtk_gesture_detach (swatch->priv->long_press_gesture);
g_object_unref (swatch->priv->long_press_gesture);
- gtk_widget_remove_controller (GTK_WIDGET (object),
- GTK_EVENT_CONTROLLER (swatch->priv->multipress_gesture));
+ gtk_gesture_detach (swatch->priv->multipress_gesture);
g_object_unref (swatch->priv->multipress_gesture);
G_OBJECT_CLASS (gtk_color_swatch_parent_class)->finalize (object);
site->drag_gesture = gtk_gesture_drag_new (widget);
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (site->drag_gesture),
FALSE);
- gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (site->drag_gesture),
- GTK_PHASE_NONE);
- gtk_widget_add_controller (widget, GTK_EVENT_CONTROLLER (site->drag_gesture));
+ gtk_gesture_attach (site->drag_gesture, GTK_PHASE_NONE);
g_signal_connect (widget, "button-press-event",
G_CALLBACK (gtk_drag_source_event_cb),
g_signal_handlers_disconnect_by_func (widget,
gtk_drag_source_event_cb,
site);
- gtk_widget_remove_controller (widget,
- GTK_EVENT_CONTROLLER (site->drag_gesture));
+ gtk_gesture_detach (site->drag_gesture);
g_object_set_data (G_OBJECT (widget), I_("gtk-site-data"), NULL);
}
}
* #GtkEventController is a base, low-level implementation for event
* controllers. Those react to a series of #GdkEvents, and possibly trigger
* actions as a consequence of those.
- *
- * Most usually, event controllers are attached to a widget through
- * gtk_widget_add_controller(). This ensures events received by the
- * widget are delivered to the controller. On special situations,
- * manual delivery may be desired, this can be achieved by setting
- * the capture phase to %GTK_PHASE_NONE and feeding events manually
- * through gtk_event_controller_handle_event(). See
- * gtk_event_controller_set_propagation_phase() and #GtkPropagationPhase
- * to know more about how events are delivered to event controllers.
*/
#include "config.h"
enum {
PROP_WIDGET = 1,
- PROP_EVENT_MASK,
- PROP_PROPAGATION_PHASE
+ PROP_EVENT_MASK
};
enum {
{
GtkWidget *widget;
guint evmask;
- guint propagation_phase : 2;
};
guint signals[N_SIGNALS] = { 0 };
P_("Event mask the controller handles"),
GDK_TYPE_EVENT_MASK, 0,
GTK_PARAM_READWRITE));
- /**
- * GtkEventController:propagation-phase:
- *
- * Specifies the stage in event propagation at which events are handled by the
- * controller. Note that this requires a controller to be attached through
- * gtk_widget_add_controller().
- *
- * Since: 3.14
- */
- g_object_class_install_property (object_class,
- PROP_PROPAGATION_PHASE,
- g_param_spec_enum ("propagation-phase",
- P_("Propagation phase"),
- P_("Phase in event propagation where this controller handles events"),
- GTK_TYPE_PROPAGATION_PHASE, GTK_PHASE_BUBBLE,
- GTK_PARAM_READWRITE));
/**
* GtkEventController::handle-event:
* @controller: the object which receives the signal
static void
gtk_event_controller_init (GtkEventController *controller)
{
- GtkEventControllerPrivate *priv;
-
- priv = gtk_event_controller_get_instance_private (controller);
- priv->propagation_phase = GTK_PHASE_BUBBLE;
}
/**
g_signal_emit (controller, signals[RESET], 0);
}
-
-/**
- * gtk_event_controller_get_propagation_phase:
- * @controller: a #GtkEventController
- *
- * Gets the propagation phase at which this @controller is run.
- *
- * Returns: The propagation phase
- *
- * Since: 3.14
- **/
-GtkPropagationPhase
-gtk_event_controller_get_propagation_phase (GtkEventController *controller)
-{
- GtkEventControllerPrivate *priv;
-
- g_return_val_if_fail (GTK_IS_EVENT_CONTROLLER (controller), GTK_PHASE_NONE);
-
- priv = gtk_event_controller_get_instance_private (controller);
-
- return priv->propagation_phase;
-}
-
-/**
- * gtk_event_controller_set_propagation_phase:
- * @controller: a #GtkEventController
- * @phase: the propagation phase
- *
- * Sets the propagation phase at which this @controller is run. Note that
- * event controllers are run before the regular #GtkWidget::event handler.
- *
- * Since: 3.14
- **/
-void
-gtk_event_controller_set_propagation_phase (GtkEventController *controller,
- GtkPropagationPhase phase)
-{
- GtkEventControllerPrivate *priv;
-
- g_return_if_fail (GTK_IS_EVENT_CONTROLLER (controller));
- g_return_if_fail (phase >= GTK_PHASE_NONE && phase <= GTK_PHASE_CAPTURE);
-
- priv = gtk_event_controller_get_instance_private (controller);
-
- if (priv->propagation_phase == phase)
- return;
-
- priv->propagation_phase = phase;
- g_object_notify (G_OBJECT (controller), "propagation-phase");
-}
GDK_AVAILABLE_IN_3_14
void gtk_event_controller_reset (GtkEventController *controller);
-GDK_AVAILABLE_IN_3_14
-GtkPropagationPhase
- gtk_event_controller_get_propagation_phase (GtkEventController *controller);
-
-GDK_AVAILABLE_IN_3_14
-void gtk_event_controller_set_propagation_phase (GtkEventController *controller,
- GtkPropagationPhase phase);
-
G_END_DECLS
#endif /* __GTK_EVENT_CONTROLLER_H__ */
#include "config.h"
#include "gtkgesture.h"
+#include "gtkwidgetprivate.h"
#include "gtkgestureprivate.h"
#include "gtktypebuiltins.h"
#include "gtkprivate.h"
return FALSE;
}
+
+/**
+ * gtk_gesture_attach:
+ * @gesture: a #GtkGesture
+ * @phase: phase at which events are handled
+ *
+ * Attaches @gesture to its widget, so @gesture is able to receive
+ * and manage the events that are emitted on the #GtkWidget. This call
+ * will also make sure that the gesture state is maintained properly
+ * whenever input is grabbed elsewhere.
+ *
+ * If @phase is %GTK_PHASE_NONE, no automatical event handling will be
+ * performed, but other additional gesture maintenance will. The events
+ * can be managed by calling gtk_event_controller_handle_event().
+ *
+ * Since: 3.14
+ **/
+void
+gtk_gesture_attach (GtkGesture *gesture,
+ GtkPropagationPhase phase)
+{
+ GtkWidget *widget;
+
+ g_return_if_fail (GTK_IS_GESTURE (gesture));
+ g_return_if_fail (phase >= GTK_PHASE_NONE && phase <= GTK_PHASE_BUBBLE);
+
+ widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
+ _gtk_widget_add_controller (widget, GTK_EVENT_CONTROLLER (gesture), phase);
+}
+
+/**
+ * gtk_gesture_detach:
+ * @gesture: a #GtkGesture
+ *
+ * Detaches @gesture from its widget.
+ *
+ * Since: 3.14
+ **/
+void
+gtk_gesture_detach (GtkGesture *gesture)
+{
+ GtkWidget *widget;
+
+ g_return_if_fail (GTK_IS_GESTURE (gesture));
+
+ widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
+ _gtk_widget_remove_controller (widget, GTK_EVENT_CONTROLLER (gesture));
+}
gboolean gtk_gesture_is_grouped_with (GtkGesture *gesture,
GtkGesture *other);
+GDK_AVAILABLE_IN_3_14
+void gtk_gesture_attach (GtkGesture *gesture,
+ GtkPropagationPhase phase);
+GDK_AVAILABLE_IN_3_14
+void gtk_gesture_detach (GtkGesture *gesture);
+
G_END_DECLS
#endif /* __GTK_GESTURE_H__ */
if (priv->long_press_gesture)
{
- gtk_widget_remove_controller (widget, GTK_EVENT_CONTROLLER (priv->long_press_gesture));
+ gtk_gesture_detach (priv->long_press_gesture);
g_clear_object (&priv->long_press_gesture);
}
{
if (zoom_set)
{
- gtk_widget_remove_controller (GTK_WIDGET (range),
- GTK_EVENT_CONTROLLER (range->priv->long_press_gesture));
+ gtk_gesture_detach (range->priv->long_press_gesture);
g_clear_object (&range->priv->long_press_gesture);
}
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (priv->long_press_gesture),
FALSE);
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (priv->long_press_gesture), 1);
- gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->long_press_gesture),
- GTK_PHASE_NONE);
+ gtk_gesture_attach (priv->long_press_gesture, GTK_PHASE_NONE);
g_signal_connect (priv->long_press_gesture, "pressed",
G_CALLBACK (hold_action), range);
priv->drag_gesture = gtk_gesture_drag_new (widget);
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (priv->drag_gesture), 1);
- gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->drag_gesture),
- GTK_PHASE_CAPTURE);
g_signal_connect_swapped (priv->drag_gesture, "drag-begin",
G_CALLBACK (scrolled_window_drag_begin_cb),
scrolled_window);
priv->swipe_gesture = gtk_gesture_swipe_new (widget);
gtk_gesture_group (priv->swipe_gesture, priv->drag_gesture);
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (priv->swipe_gesture), 1);
- gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->swipe_gesture),
- GTK_PHASE_CAPTURE);
g_signal_connect_swapped (priv->swipe_gesture, "swipe",
G_CALLBACK (scrolled_window_swipe_cb),
scrolled_window);
priv->long_press_gesture = gtk_gesture_long_press_new (widget);
gtk_gesture_group (priv->long_press_gesture, priv->drag_gesture);
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (priv->long_press_gesture), 1);
- gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->long_press_gesture),
- GTK_PHASE_CAPTURE);
g_signal_connect_swapped (priv->long_press_gesture, "pressed",
G_CALLBACK (scrolled_window_long_press_cb),
scrolled_window);
if (priv->kinetic_scrolling)
{
- gtk_widget_add_controller (GTK_WIDGET (scrolled_window),
- GTK_EVENT_CONTROLLER (priv->drag_gesture));
- gtk_widget_add_controller (GTK_WIDGET (scrolled_window),
- GTK_EVENT_CONTROLLER (priv->swipe_gesture));
- gtk_widget_add_controller (GTK_WIDGET (scrolled_window),
- GTK_EVENT_CONTROLLER (priv->long_press_gesture));
+ gtk_gesture_attach (priv->drag_gesture, GTK_PHASE_CAPTURE);
+ gtk_gesture_attach (priv->swipe_gesture, GTK_PHASE_CAPTURE);
+ gtk_gesture_attach (priv->long_press_gesture, GTK_PHASE_CAPTURE);
}
else
{
- gtk_widget_remove_controller (GTK_WIDGET (scrolled_window),
- GTK_EVENT_CONTROLLER (priv->drag_gesture));
- gtk_widget_remove_controller (GTK_WIDGET (scrolled_window),
- GTK_EVENT_CONTROLLER (priv->swipe_gesture));
- gtk_widget_remove_controller (GTK_WIDGET (scrolled_window),
- GTK_EVENT_CONTROLLER (priv->long_press_gesture));
+ gtk_gesture_detach (priv->drag_gesture);
+ gtk_gesture_detach (priv->swipe_gesture);
+ gtk_gesture_detach (priv->long_press_gesture);
gtk_scrolled_window_cancel_deceleration (scrolled_window);
}
gtk_widget_add_events (GTK_WIDGET (spin_button), GDK_SCROLL_MASK);
priv->long_press_gesture = gtk_gesture_long_press_new (GTK_WIDGET (spin_button));
- gtk_widget_add_controller (GTK_WIDGET (spin_button),
- GTK_EVENT_CONTROLLER (priv->long_press_gesture));
- gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->long_press_gesture),
- GTK_PHASE_NONE);
+ gtk_gesture_attach (priv->long_press_gesture, GTK_PHASE_NONE);
g_signal_connect (priv->long_press_gesture, "pressed",
G_CALLBACK (long_press_action), spin_button);
g_signal_connect (priv->long_press_gesture, "cancelled",
G_CALLBACK (long_press_cancel_action), spin_button);
priv->swipe_gesture = gtk_gesture_swipe_new (GTK_WIDGET (spin_button));
- gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->swipe_gesture),
- GTK_PHASE_NONE);
- gtk_widget_add_controller (GTK_WIDGET (spin_button),
- GTK_EVENT_CONTROLLER (priv->swipe_gesture));
+ gtk_gesture_attach (priv->swipe_gesture, GTK_PHASE_NONE);
g_signal_connect (priv->swipe_gesture, "update",
G_CALLBACK (swipe_gesture_update), spin_button);
}
if (priv->up_panel_context)
g_object_unref (priv->up_panel_context);
- gtk_widget_remove_controller (GTK_WIDGET (spin_button),
- GTK_EVENT_CONTROLLER (priv->long_press_gesture));
+ gtk_gesture_detach (priv->long_press_gesture);
g_object_unref (priv->long_press_gesture);
- gtk_widget_add_controller (GTK_WIDGET (spin_button),
- GTK_EVENT_CONTROLLER (priv->swipe_gesture));
+ gtk_gesture_detach (priv->swipe_gesture);
g_object_unref (priv->swipe_gesture);
G_OBJECT_CLASS (gtk_spin_button_parent_class)->finalize (object);
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (tree_view->priv->multipress_gesture), FALSE);
g_signal_connect (tree_view->priv->multipress_gesture, "pressed",
G_CALLBACK (_tree_view_multipress_pressed), tree_view);
- gtk_widget_add_controller (GTK_WIDGET (tree_view),
- GTK_EVENT_CONTROLLER (tree_view->priv->multipress_gesture));
+ gtk_gesture_attach (tree_view->priv->multipress_gesture, GTK_PHASE_BUBBLE);
}
\f
if (tree_view->priv->multipress_gesture)
{
- gtk_widget_remove_controller (GTK_WIDGET (tree_view),
- GTK_EVENT_CONTROLLER (tree_view->priv->multipress_gesture));
+ gtk_gesture_detach (tree_view->priv->multipress_gesture);
g_clear_object (&tree_view->priv->multipress_gesture);
}
typedef struct {
GtkEventController *controller;
+ GtkPropagationPhase phase;
guint evmask_notify_id;
guint grab_notify_id;
guint sequence_state_changed_id;
for (l = priv->event_controllers; l; l = l->next)
{
- GtkPropagationPhase propagation_phase;
GtkEventSequenceState gesture_state;
gboolean sequence_handled, retval;
EventControllerData *data;
handled |= retval;
g_signal_handler_unblock (data->controller, data->sequence_state_changed_id);
- propagation_phase = gtk_event_controller_get_propagation_phase (data->controller);
/* If the sequence goes denied, check whether this is a controller attached
* to the capture phase, that additionally handled the button/touch press (ie.
* beneath, so the widgets beneath get a coherent stream of events from now on.
*/
if (retval && sequence_handled &&
- propagation_phase == GTK_PHASE_CAPTURE &&
+ data->phase == GTK_PHASE_CAPTURE &&
state == GTK_EVENT_SEQUENCE_DENIED)
send_event = TRUE;
}
{
data = l->data;
- if (phase == gtk_event_controller_get_propagation_phase (data->controller))
+ if (phase == data->phase)
handled |= gtk_event_controller_handle_event (data->controller, event);
}
while (priv->event_controllers)
{
EventControllerData *data = priv->event_controllers->data;
- gtk_widget_remove_controller (widget, data->controller);
+ _gtk_widget_remove_controller (widget, data->controller);
}
G_OBJECT_CLASS (gtk_widget_parent_class)->dispose (object);
EventControllerData *data)
{
GtkWidget *grab_widget, *toplevel;
- GtkPropagationPhase phase;
GtkWindowGroup *group;
GdkDevice *device;
if (!grab_widget || grab_widget == widget)
return;
- phase = gtk_event_controller_get_propagation_phase (data->controller);
-
- if (((phase == GTK_PHASE_NONE ||
- phase == GTK_PHASE_BUBBLE) &&
+ if (((data->phase == GTK_PHASE_NONE ||
+ data->phase == GTK_PHASE_BUBBLE) &&
!gtk_widget_is_ancestor (widget, grab_widget)) ||
- (phase == GTK_PHASE_CAPTURE &&
+ (data->phase == GTK_PHASE_CAPTURE &&
!gtk_widget_is_ancestor (widget, grab_widget) &&
!gtk_widget_is_ancestor (grab_widget, widget)))
{
return NULL;
}
-/**
- * gtk_widget_add_controller:
- * @widget: a #GtkWidget, must be the same than the one passed on construction to @controller
- * @controller: a #GtkEventController
- *
- * Adds @controller to the list of controllers that are triggered
- * any time @widget receives events. the stage at which the events
- * are delivered to @controller is mandated by
- * gtk_event_controller_get_propagation_phase(). @widget will also take care
- * of calling gtk_event_controller_reset() whenever input is grabbed
- * elsewhere.
- *
- * Since: 3.14
- **/
void
-gtk_widget_add_controller (GtkWidget *widget,
- GtkEventController *controller)
+_gtk_widget_add_controller (GtkWidget *widget,
+ GtkEventController *controller,
+ GtkPropagationPhase phase)
{
EventControllerData *data;
GtkWidgetPrivate *priv;
g_return_if_fail (GTK_IS_EVENT_CONTROLLER (controller));
g_return_if_fail (widget == gtk_event_controller_get_widget (controller));
g_return_if_fail (!_gtk_widget_has_controller (widget, controller));
+ g_return_if_fail (phase >= GTK_PHASE_NONE && phase <= GTK_PHASE_BUBBLE);
priv = widget->priv;
+ data = _gtk_widget_has_controller (widget, controller);
+
+ if (data)
+ {
+ data->phase = phase;
+ return;
+ }
data = g_new0 (EventControllerData, 1);
data->controller = g_object_ref (controller);
+ data->phase = phase;
data->evmask_notify_id =
g_signal_connect (controller, "notify::event-mask",
G_CALLBACK (event_controller_notify_event_mask), widget);
_gtk_widget_update_evmask (widget);
}
-/**
- * gtk_widget_remove_controller:
- * @widget: a #GtkWidget
- * @controller: a #GtkEventController attached to @widget
- *
- * Removes @controller from the list of controllers managed by @widget.
- **/
void
-gtk_widget_remove_controller (GtkWidget *widget,
- GtkEventController *controller)
+_gtk_widget_remove_controller (GtkWidget *widget,
+ GtkEventController *controller)
{
EventControllerData *data;
GtkWidgetPrivate *priv;
g_object_unref (data->controller);
g_free (data);
}
-
-/**
- * gtk_widget_list_controllers:
- * @widget: a #GtkWidget
- *
- * Returns the list of controllers that are managed by @widget.
- *
- * Returns: (transfer container) (element-type GtkEventController): the list of
- * controllers, free with g_list_free()
- *
- * Since: 3.14
- **/
-GList *
-gtk_widget_list_controllers (GtkWidget *widget)
-{
- EventControllerData *data;
- GtkWidgetPrivate *priv;
- GList *l, *retval = NULL;
-
- g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
-
- priv = widget->priv;
-
- for (l = priv->event_controllers; l; l = l->next)
- {
- data = l->data;
- retval = g_list_prepend (retval, data->controller);
- }
-
- return retval;
-}
const gchar *name,
gboolean internal_child,
gssize struct_offset);
-GDK_AVAILABLE_IN_3_14
-void gtk_widget_add_controller (GtkWidget *widget,
- GtkEventController *controller);
-GDK_AVAILABLE_IN_3_14
-void gtk_widget_remove_controller (GtkWidget *widget,
- GtkEventController *controller);
-GDK_AVAILABLE_IN_3_14
-GList * gtk_widget_list_controllers (GtkWidget *widget);
G_END_DECLS
GActionGroup * _gtk_widget_get_action_group (GtkWidget *widget,
const gchar *prefix);
+void _gtk_widget_add_controller (GtkWidget *widget,
+ GtkEventController *controller,
+ GtkPropagationPhase phase);
+void _gtk_widget_remove_controller (GtkWidget *widget,
+ GtkEventController *controller);
+
G_END_DECLS
#endif /* __GTK_WIDGET_PRIVATE_H__ */
priv->scale = gtk_widget_get_scale_factor (widget);
priv->multipress_gesture = gtk_gesture_multi_press_new (GTK_WIDGET (window));
- gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->multipress_gesture),
- GTK_PHASE_CAPTURE);
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (priv->multipress_gesture), FALSE);
g_signal_connect (priv->multipress_gesture, "pressed",
G_CALLBACK (multipress_gesture_pressed_cb), window);
g_signal_connect (priv->multipress_gesture, "stopped",
G_CALLBACK (multipress_gesture_stopped_cb), window);
- gtk_widget_add_controller (GTK_WIDGET (window),
- GTK_EVENT_CONTROLLER (priv->multipress_gesture));
+ gtk_gesture_attach (priv->multipress_gesture, GTK_PHASE_CAPTURE);
}
static void
priv->mnemonics_display_timeout_id = 0;
}
- gtk_widget_remove_controller (GTK_WIDGET (window),
- GTK_EVENT_CONTROLLER (priv->multipress_gesture));
+ gtk_gesture_detach (priv->multipress_gesture);
g_object_unref (priv->multipress_gesture);
-
G_OBJECT_CLASS (gtk_window_parent_class)->finalize (object);
}
projects / gtk4.git / commitdiff